package com.minshenglife.zanzan.web.weixin.service;

import java.io.UnsupportedEncodingException;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import com.minshenglife.zanzan.entity.RedFlower;
import com.minshenglife.zanzan.entity.Review;
import com.minshenglife.zanzan.entity.User;
import com.minshenglife.zanzan.pub.Config;
import com.minshenglife.zanzan.pub.Keys;
import com.minshenglife.zanzan.pub.message.MessageUtil;
import com.minshenglife.zanzan.pub.message.WXRespMessage;
import com.minshenglife.zanzan.pub.message.custservice.CS_TextMessage;
import com.minshenglife.zanzan.pub.utils.Message;
import com.minshenglife.zanzan.result.RuleHelp;
import com.minshenglife.zanzan.service.RedFlowerService;
import com.minshenglife.zanzan.service.ReviewService;
import com.minshenglife.zanzan.service.RuleService;
import com.minshenglife.zanzan.service.UserService;
import com.nationsky.pub.utils.StringUtils;

@Component
public class WXReviewService {
	 Logger log = LoggerFactory.getLogger(WXReviewService.class);
	
	@Resource
	ReviewService reviewService;
	@Resource
	UserService userService;
	@Resource
	RedFlowerService redFlowerService;
	@Resource
	WXAccTokenService tokenService;
	@Resource
	RuleService ruleService;
	
	/**
	 * 添加评论
	 * @param fromOpenId 评论来源
	 * @param toContent @张三:asdfdsfdsfd
	 * @return
	 */
    public Message add(String fromOpenId,String content){
    	log.debug("start addReview method");
    	Message m=null;
    	
    	try {
    		log.debug(content);
//			String fromOpenId="";//from用户的openid
//			 content="@张三:asdfdsfdsfd";
			boolean con=checkTrue(content);
			if(!con){
				m=new Message(Message.STATE_one,"请按照以下方式送花：@姓名:评论内容");
			}else{
				String[] arr=getInfo(content);
				if(arr.length!=2){
					m=new Message(Message.STATE_one,"请按照以下方式送花：@姓名:评论内容");
				}else{
					String toUserName=arr[0];
					String toUserContent=arr[1];
					
					User user=userService.getUserByWXCode(fromOpenId);
					if(user==null){
						m=new Message(Message.STATE_one,"请先绑定员工号，再进行评论");
					}else{
						user=userService.getUserInfo(user.getEmpId());
						if(Keys.USER_EMP_TYPE_LEAVE.equals(user.getEmpType()) ){
							m=new Message(Message.STATE_one,"您不是总公司员工，请自觉离开！");
							return m;
						}
						//校验用户的机构名称是否包含“总公司”，
						if(user.getDeptName().startsWith("总公司") || "false".equals(Config.getProperty("isLimitBranch"))){
							
						}else{//不是总公司的禁止使用
							m=new Message(Message.STATE_one,"此微信暂时只对民生总公司开放，非总公司员工，请自觉离开！");
							return m;
						}
						
						List<User> users=userService.getUserByUserName(toUserName);
						if(users.size()<=0){
							m=new Message(Message.STATE_one,"被评论的【"+toUserName+"】不存在");
						}else if(users.size()!=1){
							m=new Message(Message.STATE_one,"被评论的【"+toUserName+"】存在同名情况，请确认",users);
						}else{
							String toEmpId=users.get(0).getEmpId();
							if(Keys.USER_EMP_TYPE_LEAVE.equals(users.get(0).getEmpType()) ){
								m=new Message(Message.STATE_one,"该员工已离职，请把红花送给其他员工吧！");
								return m;
							}
							String fromEmpId=user.getEmpId();
							m = toReview(toUserContent, toEmpId, fromEmpId,Keys.REVIEW_CRITICS_TYPE_ZERO);
						}
					}
				}
			}
		} catch (Exception e) {
				m=new Message(Message.STATE_one,"服务器异常");
				log.error(e.getMessage());
				e.printStackTrace();
		}
    	log.debug("end addReview method ,return message: "+m);
    	return m;
    }
    /**
     * 没有规则校验的评论方法
     * @param toUserContent
     * @param toEmpId
     * @param fromEmpId
     * @param reviewType 评论类型
     * @return
     * @throws UnsupportedEncodingException
     */
    @Transactional
	public Message toReview(String toUserContent, String toEmpId,
			String fromEmpId,String criticsType) throws UnsupportedEncodingException {
		Message m;
		//校验评论内容是否为空
		if(StringUtils.isNullOrEmpty(toUserContent)){
			return new Message(Message.STATE_one,"评论内容不能为空，请确认");
		}
		//校验可评论规则
		m=checkReviewRule(fromEmpId,toEmpId);
		if(Message.STATE_200.equals(m.getState())){
			//校验评论的内容：评论字数在5～140字之间
			int len=toUserContent.getBytes("UTF-8").length;
			if(len<15||len>420){
				m=new Message(Message.STATE_one,"评论字数在5～140字之间，请确认");
			}else{
				//添加评论信息
				Review review=new Review();
				review.setCriticsId(fromEmpId);
				review.setByCriticsId(toEmpId);
				review.setReviewContent(toUserContent);
				if(StringUtils.isNullOrEmpty(criticsType))
					criticsType=Keys.REVIEW_CRITICS_TYPE_ZERO;
				review.setCriticsType(criticsType);
				review.setContentType(Keys.REVIEW_CONTENT_TYPE_ZERO);
				reviewService.addReviewTxtInfo(review);
				
				//如果用户的赠送机会用的是抽奖得来的，需要更新用户可赠送机会:-1
				User user=userService.getUserInfo(fromEmpId);
				if(m.getType()==1){
					user.setCanSendNum(user.getCanSendNum()-1);
					userService.updateUserInfo(user);
				}
				//调用客服接口，给关注并绑定的员工发送客服消息
				try {
					User to_user=userService.getUserInfo(toEmpId);
					if(to_user==null || StringUtils.isNullOrEmpty(to_user.getWXCode())){
						log.debug("被评论的员工【"+toEmpId+"】没有绑定或没有关注赞赞，无需发送客服消息。");
					}else{
						String fromEmpName=review.getCriticsType().equals(Keys.REVIEW_CRITICS_TYPE_ONE) ? "匿名" : user.getEmp_name();
						String to_message="【"+fromEmpName+"】刚送你一朵红花，并对你说："+toUserContent;
						CS_TextMessage tm=new CS_TextMessage();
						tm.setTouser(to_user.getWXCode());
						tm.setMsgtype(MessageUtil.RESP_MESSAGE_TYPE_TEXT);
						tm.setText(to_message);
						WXRespMessage respMessage=WXBaseService.sendCustServiceMessage(tm,tokenService.getWXAccToken());
						log.info("==========="+respMessage.getErrcode());
						System.out.println("==========="+respMessage.getErrcode());
						if("0".equals(respMessage.getErrcode())){
							log.info("客服消息发送成功");
						}else{
							log.info("客服消息发送失败，错误信息："+respMessage.getErrmsg());
						}
					}
				} catch (Exception e) {
					e.printStackTrace();
					log.error(e.getMessage());
				}
				m=new Message(Message.STATE_200,"评论成功");
			}
		}
		return m;
	}
    /**
     * 校验评论规则
     *1、每人每工作日有2朵小红花，当日有效，不送即作废，每日的2朵红花不能送给相同的人
     *2、员工可将红花投给除自己以外的任何一位同事，投送给某个人的红花数不能超过投送总量的20%，
     * 		即每月送给个人的红花数不能超过9朵每月送给本部门的红花数不能超过送出总量的50%，
     *		即每个月送给本部门的红花数不能超过22朵（22个工作日计算）
     *3、送一朵红花者得一片花瓣，五片花瓣为一朵红花
     *4、员工在送出小红花的同时需参加评论，评论字数在5～140字之间，评论分为实名评论和匿名评论，员工可自主选择
     *5、每天两朵送出后，校验系统中可送花数量（幸运转盘抽奖所得），如果大于零就可以送，如果小于等于零就不可以
     * @param fromEmpId 评论来源员工号
     * @param toEmpId 被评论员工号
     * @return
     */
    private Message checkReviewRule(String fromEmpId,String toEmpId) {
    	Message m=new Message(Message.STATE_one,"评论规则校验失败！");
    	Integer isSendSecond=0;//规则定义中的赠送机会是否用完 0：否 1：是
    	try{
    		//评论人与被评论人是否为空
    		if(StringUtils.isNullOrEmpty(fromEmpId)||StringUtils.isNullOrEmpty(toEmpId)){
    			return new Message(Message.STATE_one,"用户标识获取异常，请重新进入在提交！");
    		}
    		//不能给自己评论
    		if(fromEmpId.equals(toEmpId)){
    			return new Message(Message.STATE_one,"不能对自己进行评论！");
    		}
    		
    		//获取规则定义中可赠送红花数量
    		RuleHelp rh=ruleService.getCanSendFlowerNumByRule(0);
    		Integer canSendNum=rh.getCanSendFlowerNum();
    		int tmp_canSendNum=canSendNum;
    		boolean con=false;
    		Date startDate=new Date();
    		Date endDate=new Date();
    		if(rh.getRuleStartTime()!=null && rh.getRuleEndTime()!=null){
    			startDate=rh.getRuleStartTime();
    			endDate=rh.getRuleEndTime();
    			con=true;
    		}
    		//规则1、获取该用户今天送出红花数量
    		List<RedFlower> list=redFlowerService.findMyRedFlowerList(fromEmpId,startDate,endDate,con);
    		if(canSendNum==-1){
    			log.info("canSendNum==-1；评论无限制");
    			return new Message(Message.STATE_200,"",isSendSecond);
    		}else{
        		if(list!=null){
        			canSendNum=canSendNum-list.size();
        		}
    			if(canSendNum<=0){//规则中可赠送数量已送完，看看用户信息中是否还有机会
        			isSendSecond=1;
        			//校验系统中用户的可送花数量（幸运转盘抽奖所得），如果大于零就可以送，如果小于等于零就不可以
    				User user=userService.getUserInfo(fromEmpId);
    				Long conReviewNum=user.getCanSendNum();
    				log.debug("用户抽奖所得的可评论的数量为："+conReviewNum);
    				if(conReviewNum+canSendNum<=0){
    					return new Message(Message.STATE_one,"抱歉，评论次数已用完！");
    				}
        		}
    		}
    		
    		//规则中可赠送数量未送完,判断被评论的人今天是否已经评论过了
			log.debug("规则中可赠送数量未送完,判断被评论的人今天是否已经评论过了");
			
    		//判断被评论的人今天是否已经评论过了
			for (int i=0;i<list.size();i++){
				RedFlower redflower=list.get(i);
				if(redflower.getAddManId().equals(toEmpId)){
					return new Message(Message.STATE_one,"这个员工今天已经评论过了！");
				}
			}
			
    		//新规则（add by 2014.05.19）、每天送给本部门的红花数不能超过当天可赠送红花数的一半
			//1先校验被评论的人是否是本部门的人 true（2 ）
			if(redFlowerService.isEqDept(fromEmpId, toEmpId)){
	    		Long todayNum=redFlowerService.countRedFlowerOfMonthOfDept(fromEmpId,toEmpId,startDate,endDate,con);
	    		log.debug("送给toEmpId"+toEmpId+"所在部门的红花数为："+todayNum);
	    		if( tmp_canSendNum/2<=todayNum){
	    			return new Message(Message.STATE_one,"每天送给部门或部门人员的红花数不能超过"+tmp_canSendNum/2+"次!");
	    		}
			}
    		
    		//非活动期间限制以下规则
    		if(rh.getRuleStartTime()==null && rh.getRuleEndTime() ==null){
    		
	    		Calendar c=Calendar.getInstance();
	    		c.add(Calendar.DAY_OF_MONTH,1);
				
	    		//规则2、每月送给个人的红花数不能超过9朵
	    		Long nine=redFlowerService.countRedFlowerOfMonth(fromEmpId,toEmpId,c.getTime(),new Date());
	    		if(nine==9){
	    			return new Message(Message.STATE_one,"每月对一个人的评论次数不能超过9次！");
	    		}
	    		//规则3、每个月送给本部门的红花数不能超过22朵
	    		Long num=redFlowerService.countRedFlowerOfMonthOfDept(fromEmpId,toEmpId,c.getTime(),new Date(),false);
	    		if(num==22){
	    			return new Message(Message.STATE_one,"每月对该部门员工的评论次数不能超过22次！");
	    		}
    		}
    		m=new Message(Message.STATE_200,"",isSendSecond);
	    } catch (Exception e) {
			log.error(e.getMessage());
		}
		return m;
	}

	private String[] getInfo(String str) {
//    	return (content.substring(1, content.length())).split("\\:");
		String[] arr=new String[2];
		try {
			arr[0]=str.substring(1,str.indexOf(":"));
			arr[1]=str.substring(str.indexOf(":")+1,str.length());
		} catch (Exception e) {
			e.printStackTrace();
		}
		return arr;
	}

    /**
     * 校验信息的真实性
     * 1、是否有@符号
     * 2、是否有:
     * 3、两个符号之间是否为空
     * @param content
     */
	private boolean checkTrue(String content) {
		if("".equals(content)){
			return false;
		}
		String str=content.substring(1);
		if(!"@".equals(content.substring(0,1))){
			return false;
		}else if(str.indexOf(":")==-1){
			return false;
		}else if("".equals(str.substring(0, str.indexOf(":")))){
			return false;
		}
		return true;
	}
	
	public static void main(String[] sdf){
		String content="@lisi:adfsadfdd";
		String str=content.substring(1);
		System.out.println(str);
		System.out.println(str.indexOf(":"));
		System.out.println(str.substring(0,str.indexOf(":")));
		System.out.println(str.substring(str.indexOf(":")+1,str.length()));
		String[] arr=str.split("\\:");
		System.out.println(arr.length);
		
		System.out.println((content.substring(1, content.length())).split("\\:").length);
		
		System.out.println(Float.MAX_VALUE);
		System.out.println(Double.MAX_VALUE);
	}
}
